பைதான் ரேட் லிமிட்டிங்: டோக்கன் பக்கெட் vs ஸ்லைடிங் விண்டோ - ஒரு விரிவான வழிகாட்டி

இன்றைய ஒன்றோடொன்று இணைக்கப்பட்ட உலகில், வலுவான ஏபிஐ-கள் பயன்பாட்டு வெற்றிக்கு முக்கியமானவை. இருப்பினும், கட்டுப்பாடற்ற ஏபிஐ அணுகல் சர்வர் ஓவர்லோட், சேவை குறைபாடு மற்றும் சேவையை மறுக்கும் (DoS) தாக்குதல்களுக்கு கூட வழிவகுக்கும். ரேட் லிமிட்டிங் என்பது உங்கள் ஏபிஐ-களை பாதுகாப்பதற்கான ஒரு முக்கிய நுட்பமாகும், இது ஒரு குறிப்பிட்ட நேரத்திற்குள் ஒரு பயனர் அல்லது சேவை செய்யக்கூடிய கோரிக்கைகளின் எண்ணிக்கையை கட்டுப்படுத்துகிறது. இந்த கட்டுரை பைத்தானில் இரண்டு பிரபலமான ரேட் லிமிட்டிங் அல்காரிதம்களை ஆராய்கிறது: டோக்கன் பக்கெட் மற்றும் ஸ்லைடிங் விண்டோ, விரிவான ஒப்பீடு மற்றும் நடைமுறை செயலாக்க எடுத்துக்காட்டுகளை வழங்குகிறது.

ரேட் லிமிட்டிங் ஏன் முக்கியம்

ரேட் லிமிட்டிங் பல நன்மைகளை வழங்குகிறது, அவையாவன:

• துஷ்பிரயோகத்தைத் தடுத்தல்: தீங்கிழைக்கும் பயனர்கள் அல்லது போட்களை அதிகப்படியான கோரிக்கைகளுடன் உங்கள் சர்வர்களை அதிகமாகிவிடாமல் தடுக்கிறது.
• நியாயமான பயன்பாட்டை உறுதி செய்தல்: பயனர்களிடையே வளங்களை சமமாக விநியோகிக்கிறது, ஒரு பயனர் கணினியை ஏகபோகமாக்குவதைத் தடுக்கிறது.
• உள்கட்டமைப்பைப் பாதுகாத்தல்: உங்கள் சர்வர்கள் மற்றும் தரவுத்தளங்கள் அதிகமாகி செயலிழப்பதைத் தடுக்கிறது.
• செலவுகளைக் கட்டுப்படுத்துதல்: வள நுகர்வில் எதிர்பாராத அதிகரிப்பைத் தடுக்கிறது, செலவு சேமிப்புக்கு வழிவகுக்கிறது.
• செயல்திறனை மேம்படுத்துதல்: வள பற்றாக்குறையைத் தடுப்பதன் மூலமும், நிலையான பதிலளிப்பு நேரங்களை உறுதி செய்வதன் மூலமும் நிலையான செயல்திறனைப் பராமரிக்கிறது.

ரேட் லிமிட்டிங் அல்காரிதம்களைப் புரிந்துகொள்ளுதல்

பல ரேட் லிமிட்டிங் அல்காரிதம்கள் உள்ளன, ஒவ்வொன்றும் அதன் சொந்த பலம் மற்றும் பலவீனங்களைக் கொண்டுள்ளன. நாங்கள் மிகவும் பொதுவாகப் பயன்படுத்தப்படும் இரண்டு அல்காரிதம்களில் கவனம் செலுத்துவோம்: டோக்கன் பக்கெட் மற்றும் ஸ்லைடிங் விண்டோ.

1. டோக்கன் பக்கெட் அல்காரிதம்

டோக்கன் பக்கெட் அல்காரிதம் ஒரு எளிய மற்றும் பரவலாகப் பயன்படுத்தப்படும் ரேட் லிமிட்டிங் நுட்பமாகும். இது டோக்கன்களை வைத்திருக்கும் ஒரு "பக்கெட்" பராமரிப்பதன் மூலம் செயல்படுகிறது. ஒவ்வொரு டோக்கனும் ஒரு கோரிக்கையைச் செய்வதற்கான அனுமதியைக் குறிக்கிறது. பக்கெட்டின் அதிகபட்ச கொள்ளளவு உள்ளது, மேலும் குறிப்பிட்ட விகிதத்தில் டோக்கன்கள் பக்கெட்டில் சேர்க்கப்படுகின்றன.

ஒரு கோரிக்கை வரும்போது, ரேட் லிமிட்டர் பக்கெட்டில் போதுமான டோக்கன்கள் உள்ளதா என சரிபார்க்கிறது. இருந்தால், கோரிக்கை அனுமதிக்கப்படும், மேலும் அதற்கேற்ற டோக்கன்கள் பக்கெட்டில் இருந்து நீக்கப்படும். பக்கெட் காலியாக இருந்தால், கோரிக்கை நிராகரிக்கப்படும் அல்லது போதுமான டோக்கன்கள் கிடைக்கும் வரை தாமதப்படுத்தப்படும்.

பைத்தானில் டோக்கன் பக்கெட் செயலாக்கம்

கன்கரன்சியை நிர்வகிக்க threading தொகுதியைப் பயன்படுத்தி டோக்கன் பக்கெட் அல்காரிதமின் அடிப்படை பைதான் செயலாக்கம் இங்கே:

import time
import threading

class TokenBucket:
    def __init__(self, capacity, fill_rate):
        self.capacity = float(capacity)
        self._tokens = float(capacity)
        self.fill_rate = float(fill_rate)
        self.last_refill = time.monotonic()
        self.lock = threading.Lock()

    def _refill(self):
        now = time.monotonic()
        delta = now - self.last_refill
        tokens_to_add = delta * self.fill_rate
        self._tokens = min(self.capacity, self._tokens + tokens_to_add)
        self.last_refill = now

    def consume(self, tokens):
        with self.lock:
            self._refill()
            if self._tokens >= tokens:
                self._tokens -= tokens
                return True
            return False

# எடுத்துக்காட்டு பயன்பாடு
bucket = TokenBucket(capacity=10, fill_rate=2)  # 10 டோக்கன்கள், வினாடிக்கு 2 டோக்கன்கள் வீதம் நிரப்பப்படுகிறது

for i in range(15):
    if bucket.consume(1):
        print(f"Request {i+1}: Allowed")
    else:
        print(f"Request {i+1}: Rate Limited")
    time.sleep(0.2)

விளக்கம்:

• TokenBucket(capacity, fill_rate): பக்கெட்டை அதிகபட்ச கொள்ளளவு மற்றும் நிரப்பு விகிதத்துடன் (வினாடிக்கு டோக்கன்கள்) துவக்குகிறது.
• _refill(): கடைசி நிரப்புதலுக்குப் பிறகு கழிந்த நேரத்தின் அடிப்படையில் பக்கெட்டை டோக்கன்களுடன் நிரப்புகிறது.
• consume(tokens): குறிப்பிட்ட எண்ணிக்கையிலான டோக்கன்களைப் பயன்படுத்த முயற்சிக்கிறது. வெற்றிகரமாக இருந்தால் True ஐத் திருப்பியனுப்புகிறது (கோரிக்கை அனுமதிக்கப்பட்டது), இல்லையெனில் False (கோரிக்கை ரேட் லிமிட் செய்யப்பட்டது).
• Threading Lock: கன்கரண்ட் சூழல்களில் த்ரெட் பாதுகாப்பை உறுதிசெய்ய த்ரெடிங் லாக் (self.lock) ஐப் பயன்படுத்துகிறது.

டோக்கன் பக்கெட்டின் நன்மைகள்

• செயல்படுத்த எளிதானது: புரிந்துகொள்ளவும் செயல்படுத்தவும் ஒப்பீட்டளவில் எளிமையானது.
• வெடிப்பு கையாளுதல்: பக்கெட்டில் போதுமான டோக்கன்கள் இருக்கும் வரை, போக்குவரத்தின் அவ்வப்போது வெடிப்புகளைக் கையாள முடியும்.
• கட்டமைக்கக்கூடியது: குறிப்பிட்ட தேவைகளைப் பூர்த்தி செய்ய கொள்ளளவு மற்றும் நிரப்பு விகிதத்தை எளிதாக சரிசெய்ய முடியும்.

டோக்கன் பக்கெட்டின் குறைபாடுகள்

• முழுமையாக துல்லியமானது அல்ல: நிரப்புதல் பொறிமுறையின் காரணமாக, கட்டமைக்கப்பட்ட விகிதத்தை விட சற்று அதிகமான கோரிக்கைகளை அனுமதிக்கலாம்.
• பாராமீட்டர் ட்யூனிங்: விரும்பிய ரேட் லிமிட்டிங் நடத்தையை அடைய கொள்ளளவு மற்றும் நிரப்பு விகிதத்தை கவனமாக தேர்ந்தெடுக்க வேண்டும்.

2. ஸ்லைடிங் விண்டோ அல்காரிதம்

ஸ்லைடிங் விண்டோ அல்காரிதம் என்பது நேரத்தை நிலையான அளவு கொண்ட விண்டோக்களாகப் பிரிக்கும் ஒரு துல்லியமான ரேட் லிமிட்டிங் நுட்பமாகும். இது ஒவ்வொரு விண்டோவிலும் செய்யப்பட்ட கோரிக்கைகளின் எண்ணிக்கையைக் கண்காணிக்கிறது. ஒரு புதிய கோரிக்கை வரும்போது, தற்போதைய விண்டோவில் உள்ள கோரிக்கைகளின் எண்ணிக்கை வரம்பை மீறுகிறதா என்பதை அல்காரிதம் சரிபார்க்கிறது. மீறினால், கோரிக்கை நிராகரிக்கப்படும் அல்லது தாமதப்படுத்தப்படும்.

புதிய கோரிக்கைகள் வரும்போது விண்டோ முன்னோக்கி நகர்வதால் "ஸ்லைடிங்" அம்சம் வருகிறது. தற்போதைய விண்டோ முடிவடையும் போது, ஒரு புதிய விண்டோ தொடங்குகிறது, மேலும் எண்ணிக்கை மீட்டமைக்கப்படுகிறது. ஸ்லைடிங் விண்டோ அல்காரிதமின் இரண்டு முக்கிய வேறுபாடுகள் உள்ளன: ஸ்லைடிங் லாக் மற்றும் ஃபிக்சட் விண்டோ கவுண்டர்.

2.1. ஸ்லைடிங் லாக்

ஸ்லைடிங் லாக் அல்காரிதம் ஒரு குறிப்பிட்ட நேர விண்டோவில் செய்யப்பட்ட ஒவ்வொரு கோரிக்கையின் டைம்ஸ்டாம்ப் செய்யப்பட்ட பதிவை பராமரிக்கிறது. ஒரு புதிய கோரிக்கை வரும்போது, அது விண்டோவில் விழும் அனைத்து கோரிக்கைகளையும் கணக்கிட்டு, அதை ரேட் லிமிட் உடன் ஒப்பிடுகிறது. இது துல்லியமானது, ஆனால் மெமரி மற்றும் செயலாக்க சக்திக்கு விலை உயர்ந்ததாக இருக்கும்.

2.2. ஃபிக்சட் விண்டோ கவுண்டர்

ஃபிக்சட் விண்டோ கவுண்டர் அல்காரிதம் நேரத்தை நிலையான விண்டோக்களாகப் பிரித்து, ஒவ்வொரு விண்டோவிற்கும் ஒரு கவுண்டரை வைத்திருக்கும். ஒரு புதிய கோரிக்கை வரும்போது, அல்காரிதம் தற்போதைய விண்டோவிற்கான கவுண்டரை அதிகரிக்கும். கவுண்டர் வரம்பை மீறினால், கோரிக்கை நிராகரிக்கப்படும். இது ஸ்லைடிங் லாக்கை விட எளிமையானது, ஆனால் இரண்டு விண்டோக்களின் எல்லையில் ஒரு கோரிக்கை வெடிப்பை அனுமதிக்கலாம்.

பைத்தானில் ஸ்லைடிங் விண்டோ செயலாக்கம் (ஃபிக்சட் விண்டோ கவுண்டர்)

ஃபிக்சட் விண்டோ கவுண்டர் அணுகுமுறையைப் பயன்படுத்தி ஸ்லைடிங் விண்டோ அல்காரிதமின் பைதான் செயலாக்கம் இங்கே:

import time
import threading

class SlidingWindowCounter:
    def __init__(self, window_size, max_requests):
        self.window_size = window_size  # வினாடிகள்
        self.max_requests = max_requests
        self.request_counts = {}
        self.lock = threading.Lock()

    def is_allowed(self, client_id):
        with self.lock:
            current_time = int(time.time())
            window_start = current_time - self.window_size

            # பழைய கோரிக்கைகளை சுத்தம் செய்தல்
            self.request_counts = {ts: count for ts, count in self.request_counts.items() if ts > window_start}

            total_requests = sum(self.request_counts.values())

            if total_requests < self.max_requests:
                self.request_counts[current_time] = self.request_counts.get(current_time, 0) + 1
                return True
            else:
                return False


# எடுத்துக்காட்டு பயன்பாடு
window_size = 60  # 60 வினாடிகள்
max_requests = 10  # ஒரு நிமிடத்திற்கு 10 கோரிக்கைகள்
rate_limiter = SlidingWindowCounter(window_size, max_requests)

client_id = "user123"

for i in range(15):
    if rate_limiter.is_allowed(client_id):
        print(f"Request {i+1}: Allowed")
    else:
        print(f"Request {i+1}: Rate Limited")
    time.sleep(5)

விளக்கம்:

• SlidingWindowCounter(window_size, max_requests): விண்டோ அளவு (வினாடிகளில்) மற்றும் விண்டோவில் அனுமதிக்கப்பட்ட அதிகபட்ச கோரிக்கைகளின் எண்ணிக்கையுடன் துவக்குகிறது.
• is_allowed(client_id): வாடிக்கையாளர் கோரிக்கை செய்ய அனுமதிக்கப்பட்டுள்ளாரா என சரிபார்க்கிறது. இது விண்டோவுக்கு வெளியே உள்ள பழைய கோரிக்கைகளை சுத்தம் செய்து, மீதமுள்ள கோரிக்கைகளை கூட்டி, வரம்பு மீறப்படாவிட்டால் தற்போதைய விண்டோவிற்கான எண்ணிக்கையை அதிகரிக்கிறது.
• self.request_counts: கோரிக்கை டைம்ஸ்டாம்ப்கள் மற்றும் அவற்றின் எண்ணிக்கையை சேமிக்கும் ஒரு அகராதி, இது பழைய கோரிக்கைகளை தொகுக்கவும் சுத்தம் செய்யவும் அனுமதிக்கிறது.
• Threading Lock: கன்கரண்ட் சூழல்களில் த்ரெட் பாதுகாப்பை உறுதிசெய்ய த்ரெடிங் லாக் (self.lock) ஐப் பயன்படுத்துகிறது.

ஸ்லைடிங் விண்டோவின் நன்மைகள்

• மிகவும் துல்லியமானது: டோக்கன் பக்கெட்டை விட மிகவும் துல்லியமான ரேட் லிமிட்டிங்கை வழங்குகிறது, குறிப்பாக ஸ்லைடிங் லாக் செயலாக்கம்.
• எல்லை வெடிப்புகளைத் தடுக்கிறது: இரண்டு நேர விண்டோக்களின் எல்லையில் வெடிப்புகளின் சாத்தியத்தை குறைக்கிறது (ஸ்லைடிங் லாக்குடன் மிகவும் திறம்பட).

ஸ்லைடிங் விண்டோவின் குறைபாடுகள்

• மேலும் சிக்கலானது: டோக்கன் பக்கெட்டை விட செயல்படுத்தவும் புரிந்துகொள்ளவும் மிகவும் சிக்கலானது.
• அதிக ஓவர்ஹெட்: கோரிக்கை பதிவுகளை சேமித்து செயலாக்க வேண்டியதன் காரணமாக, ஸ்லைடிங் லாக் செயலாக்கம் குறிப்பாக அதிக ஓவர்ஹெட் கொண்டிருக்கும்.

டோக்கன் பக்கெட் vs ஸ்லைடிங் விண்டோ: ஒரு விரிவான ஒப்பீடு

டோக்கன் பக்கெட் மற்றும் ஸ்லைடிங் விண்டோ அல்காரிதம்களுக்கு இடையே உள்ள முக்கிய வேறுபாடுகளை அட்டவணை இங்கே சுருக்கமாகக் கூறுகிறது:

அம்சம்	டோக்கன் பக்கெட்	ஸ்லைடிங் விண்டோ
சிக்கலானது	எளிமையானது	மேலும் சிக்கலானது
துல்லியம்	குறைந்த துல்லியம்	மேலும் துல்லியம்
வெடிப்பு கையாளுதல்	நன்று	நன்று (குறிப்பாக ஸ்லைடிங் லாக்)
ஓவர்ஹெட்	குறைவு	அதிகம் (குறிப்பாக ஸ்லைடிங் லாக்)
செயலாக்க முயற்சி	எளிதானது	கடினமானது

சரியான அல்காரிதமைத் தேர்ந்தெடுத்தல்

டோக்கன் பக்கெட் மற்றும் ஸ்லைடிங் விண்டோ இடையே உள்ள தேர்வு உங்கள் குறிப்பிட்ட தேவைகள் மற்றும் முன்னுரிமைகளைப் பொறுத்தது. பின்வரும் காரணிகளைக் கவனியுங்கள்:

• துல்லியம்: உங்களுக்கு மிகவும் துல்லியமான ரேட் லிமிட்டிங் தேவைப்பட்டால், ஸ்லைடிங் விண்டோ அல்காரிதம் பொதுவாக விரும்பப்படுகிறது.
• சிக்கலானது: எளிமை ஒரு முன்னுரிமையாக இருந்தால், டோக்கன் பக்கெட் அல்காரிதம் ஒரு நல்ல தேர்வாகும்.
• செயல்திறன்: செயல்திறன் முக்கியமானது என்றால், ஸ்லைடிங் விண்டோ அல்காரிதமின் ஓவர்ஹெட்டை கவனமாக பரிசீலிக்கவும், குறிப்பாக ஸ்லைடிங் லாக் செயலாக்கம்.
• வெடிப்பு கையாளுதல்: இரண்டு அல்காரிதம்களும் டிராஃபிக்கின் வெடிப்புகளைக் கையாள முடியும், ஆனால் ஸ்லைடிங் விண்டோ (ஸ்லைடிங் லாக்) வெடிப்பு நிலைகளில் மிகவும் நிலையான ரேட் லிமிட்டிங்கை வழங்குகிறது.
• ஸ்கேலபிலிட்டி: மிகவும் ஸ்கேலபிள் சிஸ்டம்களுக்கு, டிஸ்ட்ரிபியூட்டட் ரேட் லிமிட்டிங் நுட்பங்களைப் பயன்படுத்துவதைக் கவனியுங்கள் (கீழே விவாதிக்கப்பட்டுள்ளது).

பல சந்தர்ப்பங்களில், டோக்கன் பக்கெட் அல்காரிதம் ஒப்பீட்டளவில் குறைந்த செயலாக்க செலவில் போதுமான ரேட் லிமிட்டிங்கை வழங்குகிறது. இருப்பினும், மிகவும் துல்லியமான ரேட் லிமிட்டிங்கைத் தேவைப்படும் மற்றும் அதிகரிக்கும் சிக்கலை பொறுத்துக்கொள்ளக்கூடிய பயன்பாடுகளுக்கு, ஸ்லைடிங் விண்டோ அல்காரிதம் ஒரு சிறந்த தேர்வாகும்.

டிஸ்ட்ரிபியூட்டட் ரேட் லிமிட்டிங்

டிஸ்ட்ரிபியூட்டட் சிஸ்டம்களில், பல சர்வர்கள் கோரிக்கைகளைக் கையாளும் போது, அனைத்து சர்வர்களிலும் நிலையான ரேட் லிமிட்டிங்கை உறுதிப்படுத்த ஒரு மையப்படுத்தப்பட்ட ரேட் லிமிட்டிங் பொறிமுறை பெரும்பாலும் தேவைப்படுகிறது. டிஸ்ட்ரிபியூட்டட் ரேட் லிமிட்டிங்கிற்கு பல அணுகுமுறைகளைப் பயன்படுத்தலாம்:

• மையப்படுத்தப்பட்ட தரவு சேமிப்பு: ரேட் லிமிட்டிங் நிலையை (எ.கா., டோக்கன் எண்ணிக்கைகள் அல்லது கோரிக்கை பதிவுகள்) சேமிக்க Redis அல்லது Memcached போன்ற மையப்படுத்தப்பட்ட தரவு சேமிப்பைப் பயன்படுத்தவும். அனைத்து சர்வர்களும் ரேட் லிமிட்களை செயல்படுத்த பகிரப்பட்ட தரவு சேமிப்பை அணுகி புதுப்பிக்கின்றன.
• லோட் பேலன்சர் ரேட் லிமிட்டிங்: ஐபி முகவரி, பயனர் ஐடி அல்லது பிற அளவுகோல்களின் அடிப்படையில் ரேட் லிமிட்டிங்கைச் செய்ய உங்கள் லோட் பேலன்சரை கட்டமைக்கவும். இந்த அணுகுமுறை உங்கள் ஏபிஐ சர்வர்களில் இருந்து ரேட் லிமிட்டிங்கை குறைக்க முடியும்.
• பிரத்தியேக ரேட் லிமிட்டிங் சேவை: அனைத்து ரேட் லிமிட்டிங் கோரிக்கைகளையும் கையாளும் ஒரு பிரத்தியேக ரேட் லிமிட்டிங் சேவையை உருவாக்கவும். இந்த சேவையை சுயாதீனமாக அளவிட முடியும் மற்றும் செயல்திறனுக்காக மேம்படுத்த முடியும்.
• கிளையண்ட்-சைடு ரேட் லிமிட்டிங்: ஒரு முதன்மை பாதுகாப்பு அல்ல என்றாலும், HTTP ஹெடர்கள் (எ.கா., X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset) வழியாக வாடிக்கையாளர்களுக்கு அவர்களின் ரேட் லிமிட்களைத் தெரிவிக்கவும். இது வாடிக்கையாளர்களை சுய-த்ரோட்லிங் செய்யவும் தேவையற்ற கோரிக்கைகளைக் குறைக்கவும் ஊக்குவிக்கலாம்.

டிஸ்ட்ரிபியூட்டட் ரேட் லிமிட்டிங்கிற்கு டோக்கன் பக்கெட் அல்காரிதமுடன் Redis ஐப் பயன்படுத்துவதற்கான ஒரு எடுத்துக்காட்டு இங்கே:

import redis
import time

class RedisTokenBucket:
    def __init__(self, redis_client, bucket_key, capacity, fill_rate):
        self.redis_client = redis_client
        self.bucket_key = bucket_key
        self.capacity = capacity
        self.fill_rate = fill_rate

    def consume(self, tokens):
        now = time.time()
        capacity = self.capacity
        fill_rate = self.fill_rate

        # Redis இல் டோக்கன் பக்கெட்டை அணுசக்தி முறையில் புதுப்பிக்க Lua ஸ்கிரிப்ட்
        script = '''
        local bucket_key = KEYS[1]
        local capacity = tonumber(ARGV[1])
        local fill_rate = tonumber(ARGV[2])
        local tokens_to_consume = tonumber(ARGV[3])
        local now = tonumber(ARGV[4])

        local last_refill = redis.call('get', bucket_key .. ':last_refill')
        if not last_refill then
            last_refill = now
            redis.call('set', bucket_key .. ':last_refill', now)
        else
            last_refill = tonumber(last_refill)
        end

        local tokens = redis.call('get', bucket_key .. ':tokens')
        if not tokens then
            tokens = capacity
            redis.call('set', bucket_key .. ':tokens', capacity)
        else
            tokens = tonumber(tokens)
        end

        -- பக்கெட்டை நிரப்புதல்
        local time_since_last_refill = now - last_refill
        local tokens_to_add = time_since_last_refill * fill_rate
        tokens = math.min(capacity, tokens + tokens_to_add)

        -- டோக்கன்களைப் பயன்படுத்துதல்
        if tokens >= tokens_to_consume then
            tokens = tokens - tokens_to_consume
            redis.call('set', bucket_key .. ':tokens', tokens)
            redis.call('set', bucket_key .. ':last_refill', now)
            return 1  -- வெற்றி
        else
            return 0  -- ரேட் லிமிட்டட்
        end
        '''

        # Lua ஸ்கிரிப்டை செயல்படுத்துதல்
        consume_script = self.redis_client.register_script(script)
        result = consume_script(keys=[self.bucket_key], args=[capacity, fill_rate, tokens, now])
        return result == 1


# எடுத்துக்காட்டு பயன்பாடு
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)
bucket = RedisTokenBucket(redis_client, bucket_key='my_api:user123', capacity=10, fill_rate=2)

for i in range(15):
    if bucket.consume(1):
        print(f"Request {i+1}: Allowed")
    else:
        print(f"Request {i+1}: Rate Limited")
    time.sleep(0.2)

டிஸ்ட்ரிபியூட்டட் சிஸ்டம்களுக்கான முக்கிய பரிசீலனைகள்:

• அணுசக்தி: ரேஸ் கண்டிஷன்களைத் தடுக்க டோக்கன் பயன்பாடு அல்லது கோரிக்கை எண்ணிக்கை செயல்பாடுகள் அணுசக்தியுடன் இருப்பதை உறுதிசெய்யவும். Redis Lua ஸ்கிரிப்ட்கள் அணுசக்தி செயல்பாடுகளை வழங்குகின்றன.
• லேட்டன்சி: மையப்படுத்தப்பட்ட தரவு சேமிப்பை அணுகும்போது நெட்வொர்க் லேட்டன்சியைக் குறைக்கவும்.
• ஸ்கேலபிலிட்டி: எதிர்பார்க்கப்படும் சுமையை கையாளக்கூடிய தரவு சேமிப்பைத் தேர்ந்தெடுக்கவும்.
• தரவு நிலைத்தன்மை: டிஸ்ட்ரிபியூட்டட் சூழல்களில் சாத்தியமான தரவு நிலைத்தன்மை சிக்கல்களைச் சரிசெய்யவும்.

ரேட் லிமிட்டிங்கிற்கான சிறந்த நடைமுறைகள்

ரேட் லிமிட்டிங்கை செயல்படுத்தும்போது நீங்கள் பின்பற்றக்கூடிய சில சிறந்த நடைமுறைகள் இங்கே:

• ரேட் லிமிட்டிங் தேவைகளைக் கண்டறியவும்: பயன்பாட்டு முறைகள் மற்றும் வள நுகர்வின் அடிப்படையில் வெவ்வேறு ஏபிஐ எண்ட்பாயிண்ட்கள் மற்றும் பயனர் குழுக்களுக்கான பொருத்தமான ரேட் லிமிட்களை தீர்மானிக்கவும். சந்தா நிலையின் அடிப்படையில் அடுக்கு அணுகலை வழங்குவதைக் கவனியுங்கள்.
• அர்த்தமுள்ள HTTP நிலைக் குறியீடுகளைப் பயன்படுத்தவும்: ரேட் லிமிட்டிங்கை குறிக்க பொருத்தமான HTTP நிலைக் குறியீடுகளைத் திருப்பியனுப்பவும், எ.கா., 429 Too Many Requests.
• ரேட் லிமிட் ஹெடர்களைச் சேர்க்கவும்: வாடிக்கையாளர்களுக்கு அவர்களின் தற்போதைய ரேட் லிமிட் நிலையைப் பற்றி தெரிவிக்க உங்கள் ஏபிஐ பதில்களில் ரேட் லிமிட் ஹெடர்களைச் சேர்க்கவும் (எ.கா., X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset).
• தெளிவான பிழை செய்திகளை வழங்கவும்: வாடிக்கையாளர்கள் ரேட் லிமிட் செய்யப்படும்போது அவர்களுக்குத் தகவல் தரும் பிழை செய்திகளை வழங்கவும், காரணத்தை விளக்கவும் மற்றும் சிக்கலைத் தீர்ப்பதற்கான வழிகளைப் பரிந்துரைக்கவும். ஆதரவிற்கான தொடர்பு தகவலை வழங்கவும்.
• மென்மையான சரிவு செயலாக்கத்தை செயல்படுத்தவும்: ரேட் லிமிட்டிங் செயல்படுத்தப்படும்போது, கோரிக்கைகளை முழுமையாக தடுப்பதற்குப் பதிலாக, குறைக்கப்பட்ட சேவையை வழங்குவதைக் கவனியுங்கள். உதாரணமாக, கேச் செய்யப்பட்ட தரவு அல்லது குறைக்கப்பட்ட செயல்பாட்டை வழங்கலாம்.
• ரேட் லிமிட்டிங்கைக் கண்காணித்து பகுப்பாய்வு செய்யவும்: சாத்தியமான சிக்கல்களைக் கண்டறியவும் அதன் செயல்திறனை மேம்படுத்தவும் உங்கள் ரேட் லிமிட்டிங் அமைப்பைக் கண்காணிக்கவும். தேவைக்கேற்ப ரேட் லிமிட்களை சரிசெய்ய பயன்பாட்டு முறைகளை பகுப்பாய்வு செய்யவும்.
• உங்கள் ரேட் லிமிட்டிங்கைப் பாதுகாக்கவும்: கோரிக்கைகளை சரிபார்ப்பதன் மூலமும் பொருத்தமான பாதுகாப்பு நடவடிக்கைகளை செயல்படுத்துவதன் மூலமும் ரேட் லிமிட்களைத் தவிர்ப்பதைத் தடுக்கவும்.
• ரேட் லிமிட்களை ஆவணப்படுத்தவும்: உங்கள் ஏபிஐ ஆவணங்களில் உங்கள் ரேட் லிமிட்டிங் கொள்கைகளை தெளிவாக ஆவணப்படுத்தவும். வாடிக்கையாளர்கள் ரேட் லிமிட்களை எவ்வாறு கையாள்வது என்பதைக் காட்டும் எடுத்துக்காட்டு குறியீட்டை வழங்கவும்.
• உங்கள் செயலாக்கத்தை சோதிக்கவும்: இது சரியாக வேலை செய்கிறது என்பதை உறுதிப்படுத்த பல்வேறு சுமை நிலைகளின் கீழ் உங்கள் ரேட் லிமிட்டிங் செயலாக்கத்தை முழுமையாக சோதிக்கவும்.
• பிராந்திய வேறுபாடுகளைக் கவனியுங்கள்: உலகளவில் வரிசைப்படுத்தும்போது, நெட்வொர்க் லேட்டன்சி மற்றும் பயனர் நடத்தையில் உள்ள பிராந்திய வேறுபாடுகளைக் கவனியுங்கள். நீங்கள் பிராந்தியத்தின் அடிப்படையில் ரேட் லிமிட்களை சரிசெய்ய வேண்டியிருக்கலாம். உதாரணமாக, இந்தியாவைப் போன்ற மொபைல்-முதல் சந்தைக்கு, தென் கொரியா போன்ற அதிக அலைவரிசை பிராந்தியத்தை விட வித்தியாசமான ரேட் லிமிட்கள் தேவைப்படலாம்.

நிஜ-உலக எடுத்துக்காட்டுகள்

• ட்விட்டர்: ட்விட்டர் அதன் ஏபிஐ-யை துஷ்பிரயோகம் செய்வதில் இருந்தும் நியாயமான பயன்பாட்டை உறுதி செய்வதில் இருந்தும் பாதுகாக்க ரேட் லிமிட்டிங்கை விரிவாகப் பயன்படுத்துகிறது. அவர்கள் தங்கள் ரேட் லிமிட்களில் விரிவான ஆவணங்களை வழங்குகிறார்கள் மற்றும் டெவலப்பர்களுக்கு அவர்களின் ரேட் லிமிட் நிலையைப் பற்றி தெரிவிக்க HTTP ஹெடர்களைப் பயன்படுத்துகிறார்கள்.
• கிட்ஹப்: கிட்ஹப் அதன் ஏபிஐ-யின் ஸ்திரத்தன்மையைப் பராமரிக்கவும் துஷ்பிரயோகத்தைத் தடுக்கவும் ரேட் லிமிட்டிங்கை பயன்படுத்துகிறது. அவர்கள் ஐபி-அடிப்படையிலான மற்றும் பயனர்-அடிப்படையிலான ரேட் லிமிட்களின் கலவையைப் பயன்படுத்துகிறார்கள்.
• ஸ்ட்ரைப்: ஸ்ட்ரைப் அதன் கட்டண செயலாக்க ஏபிஐ-யை மோசடி நடவடிக்கைகளில் இருந்து பாதுகாக்க மற்றும் அதன் வாடிக்கையாளர்களுக்கு நம்பகமான சேவையை உறுதிசெய்ய ரேட் லிமிட்டிங்கை பயன்படுத்துகிறது.
• இ-காமர்ஸ் தளங்கள்: பல இ-காமர்ஸ் தளங்கள் தயாரிப்பு தகவல்களை ஸ்கேப் செய்வதை அல்லது ஃப்ளாஷ் விற்பனையின் போது சேவை மறுப்பு தாக்குதல்களைச் செய்வதை நோக்கமாகக் கொண்ட போட் தாக்குதல்களில் இருந்து பாதுகாக்க ரேட் லிமிட்டிங்கை பயன்படுத்துகின்றன.
• நிதி நிறுவனங்கள்: நிதி நிறுவனங்கள் அதன் ஏபிஐ-களில் ரேட் லிமிட்டிங்கை செயல்படுத்துகின்றன, இது முக்கியமான நிதி தரவுகளுக்கு அங்கீகரிக்கப்படாத அணுகலைத் தடுக்கவும், ஒழுங்குமுறை இணக்கத்தை உறுதிப்படுத்தவும்.

முடிவுரை

உங்கள் ஏபிஐ-களைப் பாதுகாப்பதற்கும் உங்கள் பயன்பாடுகளின் ஸ்திரத்தன்மை மற்றும் நம்பகத்தன்மையை உறுதி செய்வதற்கும் ரேட் லிமிட்டிங் ஒரு அத்தியாவசிய நுட்பமாகும். டோக்கன் பக்கெட் மற்றும் ஸ்லைடிங் விண்டோ அல்காரிதம்கள் இரண்டு பிரபலமான விருப்பங்களாகும், ஒவ்வொன்றும் அதன் சொந்த பலம் மற்றும் பலவீனங்களைக் கொண்டுள்ளன. இந்த அல்காரிதம்களைப் புரிந்துகொள்வதன் மூலமும் சிறந்த நடைமுறைகளைப் பின்பற்றுவதன் மூலமும், உங்கள் பைதான் பயன்பாடுகளில் ரேட் லிமிட்டிங்கை நீங்கள் திறம்பட செயல்படுத்தலாம் மற்றும் மேலும் வலுவான மற்றும் பாதுகாப்பான அமைப்புகளை உருவாக்கலாம். உங்கள் குறிப்பிட்ட தேவைகளைக் கருத்தில் கொள்ளவும், பொருத்தமான அல்காரிதமை கவனமாகத் தேர்ந்தெடுக்கவும், உங்கள் செயலாக்கம் உங்கள் தேவைகளைப் பூர்த்தி செய்கிறது என்பதை உறுதிப்படுத்த அதைக் கண்காணிக்கவும் நினைவில் கொள்ளுங்கள். உங்கள் பயன்பாடு விரிவடையும்போது, அனைத்து சர்வர்களிலும் நிலையான ரேட் லிமிட்டிங்கை பராமரிக்க டிஸ்ட்ரிபியூட்டட் ரேட் லிமிட்டிங் நுட்பங்களை ஏற்றுக்கொள்வதைக் கவனியுங்கள். ரேட் லிமிட் ஹெடர்கள் மற்றும் தகவல் தரும் பிழை செய்திகள் மூலம் ஏபிஐ நுகர்வோருடன் தெளிவான தகவல்தொடர்பின் முக்கியத்துவத்தை மறக்காதீர்கள்.